package com.ruoyi.project.comp.admin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.utils.security.AuthorizationUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.common.utils.text.Convert;
import com.ruoyi.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.web.controller.BaseController;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.page.TableDataInfo;
import com.ruoyi.project.system.post.service.IPostService;
import com.ruoyi.project.system.role.domain.Role;
import com.ruoyi.project.system.role.service.IRoleService;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;

/**
 * 管理员信息管理
 *
 * @author ruoyi
 */
@Controller
@RequestMapping("/comp/admin")
public class AdminController extends BaseController {
    private String prefix = "comp/admin";

    @Autowired
    private IUserService userService;

    @Autowired
    private IRoleService roleService;

    @Autowired
    private IPostService postService;

    /**
     * 跳转管理员列表页面
     */
    @GetMapping()
    public String admin() {
        return prefix + "/admin";
    }

    /**
     * 管理员列表查询（默认筛选usertype=01的管理员数据）
     */
    // @RequiresPermissions("comp:admin:list")
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(User user) {
        // 核心：强制筛选管理员类型为01，无需前端传递
        user.setUserType("01");
        startPage();
        List<User> list = userService.selectUserList(user);
        return getDataTable(list);
    }

    /**
     * 导出管理员数据（仅导出usertype=01的记录）
     */
    @Log(title = "管理员管理", businessType = BusinessType.EXPORT)
    // @RequiresPermissions("comp:admin:export")
    @PostMapping("/export")
    @ResponseBody
    public AjaxResult export(User user) {
        // 核心：导出时同样强制筛选管理员类型为01
        user.setUserType("01");
        List<User> list = userService.selectUserList(user);
        ExcelUtil<User> util = new ExcelUtil<>(User.class);
        return util.exportExcel(list, "管理员数据");
    }

    /**
     * 导入管理员数据（导入时自动设置usertype=01）
     */
    @Log(title = "管理员管理", businessType = BusinessType.IMPORT)
    // @RequiresPermissions("comp:admin:import")
    @PostMapping("/importData")
    @ResponseBody
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
        ExcelUtil<User> util = new ExcelUtil<>(User.class);
        List<User> userList = util.importExcel(file.getInputStream());
        // 核心：导入的用户强制设置为管理员类型01
        userList.forEach(admin -> admin.setUserType("01"));
        String message = userService.importUser(userList, updateSupport);
        return AjaxResult.success(message);
    }

    /**
     * 下载管理员导入模板
     */
    // @RequiresPermissions("comp:admin:view")
    @GetMapping("/importTemplate")
    @ResponseBody
    public AjaxResult importTemplate() {
        ExcelUtil<User> util = new ExcelUtil<>(User.class);
        return util.importTemplateExcel("管理员数据");
    }

    /**
     * 跳转新增管理员页面（移除部门相关数据）
     */
    @GetMapping("/add")
    public String add(ModelMap mmap) {
        // 仅传递角色和岗位数据，移除部门相关信息
        mmap.put("roles", roleService.selectRoleAll().stream()
                .filter(r -> !r.isAdmin())
                .collect(Collectors.toList()));
        mmap.put("posts", postService.selectPostAll());
        return prefix + "/add";
    }

    /**
     * 新增保存管理员（自动设置usertype=01）
     */
    // @RequiresPermissions("comp:admin:add")
    @Log(title = "管理员管理", businessType = BusinessType.INSERT)
    @PostMapping("/add")
    @ResponseBody
    public AjaxResult addSave(@Validated User user) {
        // 核心：新增管理员强制设置类型为01
        user.setUserType("01");

        // 重复校验逻辑（与用户一致）
        if (UserConstants.USER_NAME_NOT_UNIQUE.equals(userService.checkLoginNameUnique(user))) {
            return error("新增管理员'" + user.getLoginName() + "'失败，登录账号已存在");
        } else if (StringUtils.isNotEmpty(user.getPhonenumber())
                && UserConstants.USER_PHONE_NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
            return error("新增管理员'" + user.getLoginName() + "'失败，手机号码已存在");
        } else if (StringUtils.isNotEmpty(user.getEmail())
                && UserConstants.USER_EMAIL_NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
            return error("新增管理员'" + user.getLoginName() + "'失败，邮箱账号已存在");
        }
        return toAjax(userService.insertUser(user));
    }

    /**
     * 跳转修改管理员页面（移除部门相关数据）
     */
    // @RequiresPermissions("comp:admin:edit")
    @GetMapping("/edit/{userId}")
    public String edit(@PathVariable("userId") Long userId, ModelMap mmap) {
        // 校验管理员数据权限
        userService.checkUserDataScope(userId);
        // 获取管理员信息和关联角色（移除部门数据）
        User admin = userService.selectUserById(userId);
        List<Role> roles = roleService.selectRolesByUserId(userId);

        mmap.put("admin", admin);
        mmap.put("roles", User.isAdmin(userId) ? roles : roles.stream()
                .filter(r -> !r.isAdmin())
                .collect(Collectors.toList()));
        mmap.put("posts", postService.selectPostsByUserId(userId));
        return prefix + "/edit";
    }

    /**
     * 修改保存管理员（强制保留usertype=01，防止被篡改）
     */
    // @RequiresPermissions("comp:admin:edit")
    @Log(title = "管理员管理", businessType = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ResponseBody
    public AjaxResult editSave(@Validated User user) {
        // 校验权限
        userService.checkUserAllowed(user);
        userService.checkUserDataScope(user.getUserId());

        // 核心：强制保留管理员类型为01，防止前端或其他操作篡改
        user.setUserType("01");

        // 重复校验逻辑
        if (UserConstants.USER_NAME_NOT_UNIQUE.equals(userService.checkLoginNameUnique(user))) {
            return error("修改管理员'" + user.getLoginName() + "'失败，登录账号已存在");
        } else if (StringUtils.isNotEmpty(user.getPhonenumber())
                && UserConstants.USER_PHONE_NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
            return error("修改管理员'" + user.getLoginName() + "'失败，手机号码已存在");
        } else if (StringUtils.isNotEmpty(user.getEmail())
                && UserConstants.USER_EMAIL_NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
            return error("修改管理员'" + user.getLoginName() + "'失败，邮箱账号已存在");
        }

        AuthorizationUtils.clearAllCachedAuthorizationInfo();
        return toAjax(userService.updateUser(user));
    }





    /**
     * 删除管理员（仅允许删除usertype=01的记录，防止误删普通用户）
     */
    // @RequiresPermissions("comp:admin:remove")
    @Log(title = "管理员管理", businessType = BusinessType.DELETE)
    @PostMapping("/remove")
    @ResponseBody
    public AjaxResult remove(String ids) {
        // 1. 禁止删除当前登录用户
        if (ArrayUtils.contains(Convert.toLongArray(ids), getUserId())) {
            return error("当前管理员不能删除");
        }

        // 2. 校验待删除的记录是否均为管理员（usertype=01），防止误删普通用户
        List<Long> userIdList = Arrays.asList(Convert.toLongArray(ids));
        for (Long userId : userIdList) {
            User admin = userService.selectUserById(userId);
            if (admin == null || !"01".equals(admin.getUserType())) {
                return error("删除失败，存在非管理员记录，不允许操作");
            }
        }

        return toAjax(userService.deleteUserByIds(ids));
    }

    /**
     * 校验管理员用户名唯一性
     */
    @PostMapping("/checkLoginNameUnique")
    @ResponseBody
    public String checkLoginNameUnique(User user) {
        // 强制筛选管理员类型，确保校验的是管理员账号
        user.setUserType("01");
        return userService.checkLoginNameUnique(user);
    }

    /**
     * 校验管理员手机号码唯一性
     */
    @PostMapping("/checkPhoneUnique")
    @ResponseBody
    public String checkPhoneUnique(User user) {
        // 强制筛选管理员类型
        user.setUserType("01");
        return userService.checkPhoneUnique(user);
    }

    /**
     * 校验管理员邮箱唯一性
     */
    @PostMapping("/checkEmailUnique")
    @ResponseBody
    public String checkEmailUnique(User user) {
        // 强制筛选管理员类型
        user.setUserType("01");
        return userService.checkEmailUnique(user);
    }

    /**
     * 管理员状态修改（仅允许修改usertype=01的记录）
     */
    @Log(title = "管理员管理", businessType = BusinessType.UPDATE)
    // @RequiresPermissions("comp:admin:edit")
    @PostMapping("/changeStatus")
    @ResponseBody
    public AjaxResult changeStatus(User user) {
        // 1. 校验权限
        userService.checkUserAllowed(user);
        userService.checkUserDataScope(user.getUserId());

        // 2. 校验该记录是否为管理员（usertype=01）
        User admin = userService.selectUserById(user.getUserId());
        if (admin == null || !"01".equals(admin.getUserType())) {
            return error("操作失败，仅允许修改管理员状态");
        }

        // 3. 执行状态修改，强制保留管理员类型
        user.setUserType("01");
        return toAjax(userService.changeStatus(user));
    }
}